package com.example.concurrency.day2;

import java.io.IOException;

public class SynchronizedDemo2  {
    static Object lock = new Object();
    static Integer count=0;
    public static void incr(){
        synchronized (lock) {

            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
        }
    }
    public static void main(String[] args) throws IOException, InterruptedException {
        for(int i=0;i<1000;i++){
            new Thread(()-> SynchronizedDemo2.incr()).start();
        }
        int i = 1;
        i = (i++) + (++i);
        System.out.println(i);
        Thread.sleep(5000);
//        j=i++;
//        int t=i;i=i+1;j=t;
//        j=++i;
//        int t=i+i ;i=i+1;j=t;
        System.out.println("result:"+count);
        //结果小余1000, 因为对于基础类型包装类的数学运算,都会拆箱为基本类型在计算,然后将结果转换为包装类型.
        //这里的Integer已经被每次++操作后新生成的对象所取代,可以看到-128~128之间的是缓存的Integer对象, 就算是缓存的对象,每次synchronized关键字的锁也换了对象了
        /**
         *  if (i >= IntegerCache.low && i <= IntegerCache.high)
         *             return IntegerCache.cache[i + (-IntegerCache.low)];
         *         return new Integer(i);
         *
         *
         */
    }
}